# -*- coding: utf-8 -*-
import re
from opengov.settings import *
import httplib2
from lxml import etree
from cStringIO import StringIO
from opengov.govtrack.models import *
from htmlentitydefs import name2codepoint
import codecs
from datetime import *

# Normalisera rattsdokumentnummer
SWE_ENTITIES = {"&ouml;":u"ö", 
        "&aring;": u"å", 
        "&auml;": u"ä",
        "&Ouml;":u"Ö", 
        "&Aring;": u"Å", 
        "&Auml;": u"Ä",
        "&nbsp;": u" ",
        "&eacute;": u"é"
        }

SWE_MONTH_NUM = {"januari":1,
        "februari":2,
        "mars":3,
        "april":4,
        "maj":5,
        "juni":6,
        "juli":7,
        "augusti":8,
        "september":9,
        "oktober":10,
        "november":11,
        "december":12}


# För Python < 3
URL_ESCAPES_UTF8 = {u"ö": "%C3%B6", u"å": "%C3%A5", u"ä": "%C3%A4", u"Å": "%C3%85",u"Ä": "%C3%84", u"Ö":"%C3%96"  }

def normalize_sfsref(reference):
    # Hitta mönster for rättsinformationsreferens och normalisera
    # 2008:03 -> 2008:3
    year, ordinal = reference.split(":")
    ordinal = str(int(ordinal))
    return ":".join((year, ordinal))

def strip_newlines(text):
    return text.replace("\n", " ")

def norm_space(text):
    return " ".join(text.split()).strip()

def htmlentitydecode(s):
    for key in SWE_ENTITIES:
        s=s.replace(key, SWE_ENTITIES[key])
    return s

def url_escape_utf8(text):
    for key in URL_ESCAPES_UTF8:
        text = text.replace(key, URL_ESCAPES_UTF8[key])
    return text

def normalize(text):
    return norm_space(htmlentitydecode(text))


def lookup_utredning_rubrik_from_text(text):
    matches = re.search(u"<h1 class=\"Inhall.Rubrik1\">([^<]*)</h1>", text, re.UNICODE)

    if matches:
        return normalize(matches.groups()[0])
    else:
        return "(rubrik saknas)"


def lookup_utredning_rubrik(utredningsnummer):
    h = httplib2.Http()
    departementskod = utredningsnummer.split(" ")[0]
    nummer = utredningsnummer.split(" ")[1]

    # Anropa RK
    url = u"http://rixlex.riksdagen.se/webbnav/index.aspx?nid=3255&dok_id=B2_" + url_escape_utf8(utredningsnummer.replace(" ",""))
    resp, content = h.request(url)
    if resp["status"] == "200":
        return lookup_utredning_rubrik_from_text(content.decode("utf-8"))
    else:
        return "(rubrik saknas)"


def lookup_sfs_title(sfsnummer):
    h = httplib2.Http()

    # Anropa RK
    resp, content = h.request(u"http://62.95.69.15/cgi-bin/thw?${OOHTML}=sfsr_dok&${HTML}=sfst_lst&${SNHTML}=sfsr_err&${BASE}=SFSR&BET=%s" % sfsnummer)
    if resp["status"] == "200":
        matches = re.search(u"<td width=\"470\"><font SIZE=\"4\"><b>([^<]*)</b>", content, re.DOTALL)
        if matches:
            return normalize(matches.groups()[0].strip())

    return "(rubrik saknas)"


def lookup_celex_title(celexnummer):
    return "" #Inte implementerad än


def lookup_prop_title(nummer):
    h = httplib2.Http()
    riksmote, nummer = nummer.split(":")

    try:
        resp, content = h.request(u"http://www.riksdagen.se/webbnav/?nid=37&doktyp=prop&rm=%s&bet=%s" % (riksmote, nummer))
        content = content.decode("utf-8")
        if resp["status"] == "200":
            matches = re.search(u"<title>([^<]*)</title>", content)
            if matches:
                return normalize(matches.groups()[0].strip().replace(u" - Riksdagen", ""))
    except:
        return "(rubrik saknas)"



def find_or_create_sfsreference(sfsnummer):
    sfs = None
    print(u"Soker SFS-referens for SFS %s" % sfsnummer)

    try:
        sfs = SFSReferens.objects.get(sfsnummer__exact=sfsnummer)
        print("Hittade SFS %s" % sfsnummer)
    except SFSReferens.DoesNotExist:
        print("Skapar ny SFS-referens %s" % sfsnummer)
        sfs = SFSReferens()
        sfs.sfsnummer = sfsnummer
        sfs.rubrik = lookup_sfs_title(sfsnummer)
        sfs.save()

    return sfs



def find_or_create_proposition(nummer):
    prop = None
    print(u"Soker Prop %s" % nummer)

    try:
        prop = Proposition.objects.get(nummer__exact=nummer)
        print("Hittade Prop %s" % nummer)
    except Proposition.DoesNotExist:
        print("Skapar ny prop %s" % nummer)
        prop = Proposition()
        prop.nummer = nummer
        prop.rubrik = lookup_prop_title(nummer)
        prop.save()

    return prop


def find_or_create_celexreference(nummer):
    celex = None
    print(u"Soker Celex %s" % nummer)

    try:
        celex = CelexReferens.objects.get(celexnummer__exact=nummer)
        print("Hittade celex %s" % nummer)
    except CelexReferens.DoesNotExist:
        print("Skapar ny celexref %s" % nummer)
        celex = CelexReferens()
        celex.celexnummer = nummer
        celex.rubrik = lookup_celex_title(nummer)
        celex.save()

    return celex



def find_or_create_departement(departementtext):
    code = ""
    name = ""
    if " " in departementtext:
        code, name = departementtext.strip().split(" ",1)
        name = normalize(name)
    else:
        name = normalize(departementtext.strip())

    departement = None

    if code != "":
        try:
            departement = Departement.objects.get(code__iexact=code)
        except Departement.DoesNotExist:
            departement = Departement()
            departement.name = name
            departement.code = code
            departement.save()
    else:
        try:
            departement = Departement.objects.get(name__iexact=name)
        except Departement.DoesNotExist:
            departement = Departement()
            departement.name = name
            departement.code = code
            departement.save()

    return departement



def find_utredningsrubrik(departementskod, utredningsnummer):
    return departementskod + " " + utredningsnummer



def find_or_create_utredning(utredningsnummer):
    """Utredningsnummer på formen 'S 2008:01'"""
    utredning = None
    departementskod = utredningsnummer.split(" ")[0]

    try:
        utredning = Utredning.objects.get(nummer__iexact=utredningsnummer, departement__code__iexact=departementskod)
    except Utredning.DoesNotExist:
        utredning = Utredning()
        utredning.nummer = utredningsnummer
        rubrik = lookup_utredning_rubrik(utredningsnummer) 
        utredning.rubrik = rubrik 

        try:
            departement = Departement.objects.get(code__iexact=departementskod)
            utredning.departement = departement
        except Departement.DoesNotExist:
            print(u"Kunde inte skapa departement for utredning %s" % utredningsnummer)
        utredning.save()

    return utredning



def find_or_create_betankande(nummer):
    """ Skapa stomme till ett betänkande, eller returnera ett existerande betänkande om det redan finns """

def extract_delivery_date_from_text(filedata):
    """
    Läs ut datum från text om redovisning av uppdrag/kommitté.
    """

    delivery_date = None

    try:
        # Testa grundform
        match = re.search(u"Uppdraget\s*ska.*\s*[slut]*?redovisas\s*[a-zA-Z\s]*senast\s*den\s*(\d\d?)\s*(\w+)\s*(\d\d\d\d)", filedata)

        if not match:
            # Testa nästa form
            match = re.search(u"Kommitt.*n\s*ska.*\s*redovisa\s*sitt\s*uppdrag\s*senast\s*den\s*(\d\d?)\s*(\w+)\s*(\d\d\d\d)", filedata)

        if not match:
            # Testa nästa form
            match = re.search(u"En\s*slutredovisning\s*av\s*arbete\s*ska\s*lämnas\s*senast\s*den\s*(\d\d?)\s*(\w+)\s*(\d\d\d\d)", filedata)

        if not match:
            # Testa nästa form
            match = re.search(u"Utredaren\s*ska\s*redovisa\s*sitt\s*uppdrag\s*senast\s*den\s*(\d\d?)\s*(\w+)\s*(\d\d\d\d)", filedata)

        if not match:
            # Testa nästa form
            match = re.search(u"Uppdraget\s*i\s*.vrigt\s*ska\s*redovisas\s*senast\s*den\s*(\d\d?)\s*(\w+)\s*(\d\d\d\d)", filedata)

        if not match:
            # Testa nästa form
            match = re.search(u"Arbetet\s*ska\s*avslutas\s*med\s*en\s*skriftlig\s*rapport\s*till\s*regeringen\s*senast\s*den\s*(\d\d?)\s*(\w+)\s*(\d\d\d\d)", filedata)

        if not match:
            # Testa nästa form
            match = re.search(u"Övriga delar av uppdraget ska redovisas\s*senast\s*den\s*(\d\d?)\s*(\w+)\s*(\d\d\d\d)", filedata)

        if not match:
            # Testa nästa form
            match = re.search(u"Utredaren ska [a-z]*redovisa resultatet av sitt arbete\s*senast\s*den\s*(\d\d?)\s*(\w+)\s*(\d\d\d\d)", filedata)

        if not match:
            # Testa nästa form
            match = re.search(u"En slutrapport ska lämnas\s*senast\s*den\s*(\d\d?)\s*(\w+)\s*(\d\d\d\d)", filedata)

        if not match:
            # Testa nästa form
            match = re.search(u"Utredaren ska redovisa sitt uppdrag till regeringen\s*senast\s*den\s*(\d\d?)\s*(\w+)\s*(\d\d\d\d)", filedata)

        if not match:
            # Testa nästa form
            match = re.search(u"Utredaren ska lämna sin slutrapport\s*senast\s*den\s*(\d\d?)\s*(\w+)\s*(\d\d\d\d)", filedata)

        if not match:
            # Testa nästa form
            match = re.search(u"Redovisningen vad gäller kvarvarande frågor ska ske\s*senast\s*den\s*(\d\d?)\s*(\w+)\s*(\d\d\d\d)", filedata)

        if not match:
            # Testa nästa form
            match = re.search(u"Kommitt.*n .* och i .vriga delar senast\s*den\s*(\d\d?)\s*(\w+)\s*(\d\d\d\d)\.", filedata, re.UNICODE)

        if match:
            # Skapa datum
            if len(match.groups()) == 3:
                month = SWE_MONTH_NUM[match.groups()[1].strip().lower()]
                day = match.groups()[0]
                year = match.groups()[2]
                return date(int(year),int(month),int(day))
    except:
        return None





def extract_sfs_references_from_text(filedata):
    return re.findall("\((\d\d\d\d:\d+)\)", filedata)



def egref_to_celex(text):
    matches = re.search("(\d\d+)\/(\d*)\/EE?G", text)
    if matches:
        if len(matches.groups()) == 2:
            return "3%sL%s" % (matches.groups()[0], matches.groups()[1].rjust(4, "0"))

    return None


def extract_prop_references_from_text(filedata):
    return re.findall("\(prop\.\s*(\d\d\d\d/\d\d:\d+)", filedata)
# (prop. 1981/82:142)     (prop. 1991/92:150, del II, bet. 1991/92:FiU29, rskr. 1991/92:345)	


def extract_directive_references_from_text(filedata):
    return re.findall("\s(direktiv\s*\d\d+\/\d+\/EE?G)", filedata)


def extract_utredning_reference_from_text(text):
    match = re.findall("\((\w\w? \d\d\d\d:(?:\d\d+|\w))", text, re.UNICODE)
    if len(match) > 0:
        return match[-1] # sista matchningen i händelse av att man även gjort referens till en Ds som har samma mönster
    else:
        return None


def get_date_from_file(filepath, default_date):
    try:
        print u"Laser startdatum fran fil %s" % filepath
        f = open(filepath, "r")
        filedata = f.read()
        f.close()
        return datetime.strptime(filedata.strip(), "%Y-%m-%d").date()
    except:
        print u"Kunde inte lasa startdatum fran fil %s" % filepath
        return default_date


def store_date_in_file(filepath, the_date):
    try:
        f = open(filepath, "w")
        f.write(the_date.isoformat())
        f.close()
    except:
        print(u"Kunde inte spara datum till fil %s" % filepath)



def get_value_from_utredning_item(item):
    """Extraherar de taskigt uppmärkta dataposterna for en utredning på riksdagens webbplats."""
    try:
        return normalize(item.split(": ")[1])
    except:
        return None


def parse_first_date(text):
    """Tar ut forsta datumet på formen YYYY-MM-DD ur en sträng."""
    try:
        match = re.search("(\d\d\d\d)-(\d\d)-(\d\d)", text)
        if match:
            return date(int(match.groups()[0]),int(match.groups()[1]),int(match.groups()[2]))
    except:
        return None

def extract_komdir_references_from_text(filedata):
    return re.findall("dir\. (\d\d\d\d:\d+)", filedata, re.IGNORECASE)


def extract_komdir_numbers_from_searchresult_dom(domtree):
    """Plockar ut kommittédirektivslänkar ur domträd för RK:s sökresultatsida"""
    result = []
    for link in domtree.xpath("//a[starts-with(@href, '/cgi-bin/')]"):
        if re.search("Dir", link.text):
            result.append(link.text.split("Dir. ")[1])
        else:
            result.append(link.text)

    return result


def extract_komdir_number_from_komdir_page(content):
    """Läser ut direktivnummer från en kommittédirektivsida"""
    # Dir nr: <b>              2010:83</b> 
    # Dir nr: <b>              Dir. 2009:74</b> 
    items = re.findall("Dir nr:\s*<b>\s*\D*\s*(\d\d\d\d:\d+)\s*</b>", content, re.IGNORECASE)
    if items:
        return items[0]
    else:
        return None


def create_komdir_crawlitem(dirnr):
    ci = CrawlItem()
    ci.nummer = dirnr
    ci.klass = "Kommittedirektiv"
    ci.save()
    return

